​Pandas小册子：groupby概览

   

01

这是我去年发过的一篇文章，前几天自己在用到 groupby 的功能时又把文章翻出来看了看，遂再次分享给大家。

Pandas的 groupby()功能很强大，用好了可以方便的解决很多问题，在数据处理以及日常工作中经常能施展拳脚。

今天，我们一起来领略下 groupby()的魅力吧。

首先，引入相关package：

1. import pandas as pd

2. import numpy as np

groupby的基础操作

1. In [2]: df = pd.DataFrame({'A': ['a', 'b', 'a', 'c', 'a', 'c', 'b', 'c'],

2.   ...:                    'B': [2, 8, 1, 4, 3, 2, 5, 9],

3.   ...:                    'C': [102, 98, 107, 104, 115, 87, 92, 123]})

4.   ...: df

5.   ...:

6. Out[2]:

7.   A  B    C

8. 0  a  2  102

9. 1  b  8   98

10. 2  a  1  107

11. 3  c  4  104

12. 4  a  3  115

13. 5  c  2   87

14. 6  b  5   92

15. 7  c  9  123

按A列分组（groupby），获取其他列的均值

1. df.groupby('A').mean()

2. Out[3]:

3.     B           C

4. A                

5. a  2.0  108.000000

6. b  6.5   95.000000

7. c  5.0  104.666667

按多列进行分组（groupby）

1. df.groupby(['A','B']).mean()

2. Out[4]:

3.       C

4. A B    

5. a 1  107

6.  2  102

7.  3  115

8. b 5   92

9.  8   98

10. c 2   87

11.  4  104

12.  9  123

分组后选择列进行运算

分组后，可以选取单列数据，或者多个列组成的列表（list）进行运算

1. In [5]: df = pd.DataFrame([[1, 1, 2], [1, 2, 3], [2, 3, 4]], columns=["A", "B", "C"])

2.   ...: df

3.   ...:

4. Out[5]:

5.   A  B  C

6. 0  1  1  2

7. 1  1  2  3

8. 2  2  3  4

1. In [6]: g = df.groupby("A")

1. In [7]: g['B'].mean() # 仅选择B列

2. Out[7]:

3. A

4. 1    1.5

5. 2    3.0

6. Name: B, dtype: float64

1. In [8]: g[['B', 'C']].mean() # 选择B、C列

2. Out[8]:

3.     B    C

4. A          

5. 1  1.5  2.5

6. 2  3.0  4.0

可以针对不同的列选用不同的聚合方法

1. In [9]: g.agg({'B':'mean', 'C':'sum'})

2. Out[9]:

3.     B  C

4. A        

5. 1  1.5  5

6. 2  3.0  4

聚合方法size()和count()

size跟count的区别： size计数时包含NaN值，而count不包含NaN值

1. In [10]: df = pd.DataFrame({"Name":["Alice", "Bob", "Mallory", "Mallory", "Bob" , "Mallory"],

2.    ...:                  "City":["Seattle", "Seattle", "Portland", "Seattle", "Seattle", "Portland"],

3.    ...:                  "Val":[4,3,3,np.nan,np.nan,4]})

4.    ...:

5.    ...: df

6.    ...:

7. Out[10]:

8.       City     Name  Val

9. 0   Seattle    Alice  4.0

10. 1   Seattle      Bob  3.0

11. 2  Portland  Mallory  3.0

12. 3   Seattle  Mallory  NaN

13. 4   Seattle      Bob  NaN

14. 5  Portland  Mallory  4.0

count()

1. In [11]: df.groupby(["Name", "City"], as_index=False)['Val'].count()

2. Out[11]:

3.      Name      City  Val

4. 0    Alice   Seattle    1

5. 1      Bob   Seattle    1

6. 2  Mallory  Portland    2

7. 3  Mallory   Seattle    0

size()

1. In [12]: df.groupby(["Name", "City"])['Val'].size().reset_index(name='Size')

2. Out[12]:

3.      Name      City  Size

4. 0    Alice   Seattle     1

5. 1      Bob   Seattle     2

6. 2  Mallory  Portland     2

7. 3  Mallory   Seattle     1

分组运算方法 agg()

针对某列使用agg()时进行不同的统计运算

1. In [13]: df = pd.DataFrame({'A': list('XYZXYZXYZX'), 'B': [1, 2, 1, 3, 1, 2, 3, 3, 1, 2],

2.    ...:                            'C': [12, 14, 11, 12, 13, 14, 16, 12, 10, 19]})

3.    ...: df

4.    ...:

5. Out[13]:

6.   A  B   C

7. 0  X  1  12

8. 1  Y  2  14

9. 2  Z  1  11

10. 3  X  3  12

11. 4  Y  1  13

12. 5  Z  2  14

13. 6  X  3  16

14. 7  Y  3  12

15. 8  Z  1  10

16. 9  X  2  19

1. In [14]: df.groupby('A')['B'].agg({'mean':np.mean, 'standard deviation': np.std})

2. Out[14]:

3.       mean  standard deviation

4. A                              

5. X  2.250000            0.957427

6. Y  2.000000            1.000000

7. Z  1.333333            0.577350

针对不同的列应用多种不同的统计方法

1. In [15]: df.groupby('A').agg({'B':[np.mean, 'sum'], 'C':['count',np.std]})

2. Out[15]:

3.          B         C          

4.       mean sum count       std

5. A                              

6. X  2.250000   9     4  3.403430

7. Y  2.000000   6     3  1.000000

8. Z  1.333333   4     3  2.081666

分组运算方法 apply()

1. In [16]: df = pd.DataFrame({'A': list('XYZXYZXYZX'), 'B': [1, 2, 1, 3, 1, 2, 3, 3, 1, 2],

2.    ...:                            'C': [12, 14, 11, 12, 13, 14, 16, 12, 10, 19]})

3.    ...: df

4.    ...:

5. Out[16]:

6.   A  B   C

7. 0  X  1  12

8. 1  Y  2  14

9. 2  Z  1  11

10. 3  X  3  12

11. 4  Y  1  13

12. 5  Z  2  14

13. 6  X  3  16

14. 7  Y  3  12

15. 8  Z  1  10

16. 9  X  2  19

17. In [17]: df.groupby('A').apply(np.mean)

18.    ...: # 跟下面的方法的运行结果是一致的

19.    ...: # df.groupby('A').mean()

20. Out[17]:

21.          B          C

22. A                    

23. X  2.250000  14.750000

24. Y  2.000000  13.000000

25. Z  1.333333  11.666667

apply()方法可以应用lambda函数，举例如下:

1. In [18]: df.groupby('A').apply(lambda x: x['C']-x['B'])

2. Out[18]:

3. A  

4. X  0    11

5.   3     9

6.   6    13

7.   9    17

8. Y  1    12

9.   4    12

10.   7     9

11. Z  2    10

12.   5    12

13.   8     9

14. dtype: int64

15. In [19]: df.groupby('A').apply(lambda x: (x['C']-x['B']).mean())

16. Out[19]:

17. A

18. X    12.500000

19. Y    11.000000

20. Z    10.333333

21. dtype: float64

分组运算方法 transform()

前面进行聚合运算的时候，得到的结果是一个以分组名为 index 的结果对象。如果我们想使用原数组的 index 的话，就需要进行 merge 转换。transform(func, args, *kwargs) 方法简化了这个过程，它会把 func 参数应用到所有分组，然后把结果放置到原数组的 index 上（如果结果是一个标量，就进行广播）：

1. In [20]: df = pd.DataFrame({'group1' :  ['A', 'A', 'A', 'A',

2.    ...:                                'B', 'B', 'B', 'B'],

3.    ...:                    'group2' :  ['C', 'C', 'C', 'D',

4.    ...:                                'E', 'E', 'F', 'F'],

5.    ...:                    'B'      :  ['one', np.NaN, np.NaN, np.NaN,

6.    ...:                                 np.NaN, 'two', np.NaN, np.NaN],

7.    ...:                    'C'      :  [np.NaN, 1, np.NaN, np.NaN,

8.    ...:                                np.NaN, np.NaN, np.NaN, 4]})          

9.    ...: df

10.    ...:

11. Out[20]:

12.     B    C group1 group2

13. 0  one  NaN      A      C

14. 1  NaN  1.0      A      C

15. 2  NaN  NaN      A      C

16. 3  NaN  NaN      A      D

17. 4  NaN  NaN      B      E

18. 5  two  NaN      B      E

19. 6  NaN  NaN      B      F

20. 7  NaN  4.0      B      F

21. In [21]: df.groupby(['group1', 'group2'])['B'].transform('count')

22. Out[21]:

23. 0    1

24. 1    1

25. 2    1

26. 3    0

27. 4    1

28. 5    1

29. 6    0

30. 7    0

31. Name: B, dtype: int64

32. In [22]: df['count_B']=df.groupby(['group1', 'group2'])['B'].transform('count')

33.    ...: df

34.    ...:

35. Out[22]:

36.     B    C group1 group2  count_B

37. 0  one  NaN      A      C        1

38. 1  NaN  1.0      A      C        1

39. 2  NaN  NaN      A      C        1

40. 3  NaN  NaN      A      D        0

41. 4  NaN  NaN      B      E        1

42. 5  two  NaN      B      E        1

43. 6  NaN  NaN      B      F        0

44. 7  NaN  4.0      B      F        0

上面运算的结果分析： {'group1':'A', 'group2':'C'}的组合共出现3次，即index为0,1,2。对应"B"列的值分别是"one","NaN","NaN"，由于count()计数时不包括Nan值，因此{'group1':'A', 'group2':'C'}的count计数值为1。 transform()方法会将该计数值在dataframe中所有涉及的rows都显示出来（我理解应该就进行广播）

将某列数据按数据值分成不同范围段进行分组（groupby）运算

1. In [23]: np.random.seed(0)

2.    ...: df = pd.DataFrame({'Age': np.random.randint(20, 70, 100),

3.    ...:                    'Sex': np.random.choice(['Male', 'Female'], 100),

4.    ...:                    'number_of_foo': np.random.randint(1, 20, 100)})

5.    ...: df.head()

6.    ...:

7. Out[23]:

8.   Age     Sex  number_of_foo

9. 0   64  Female             14

10. 1   67  Female             14

11. 2   20  Female             12

12. 3   23    Male             17

13. 4   23  Female             15

这里将“Age”列分成三类，有两种方法可以实现：

（a）bins=4

（b）bins=[19, 40, 65, np.inf]

1. In [24]: pd.cut(df['Age'], bins=4)

2. Out[24]:

3. ...

4. In [25]: pd.cut(df['Age'], bins=[19,40,65,np.inf])

分组结果范围结果如下：

1. In [26]: age_groups = pd.cut(df['Age'], bins=[19,40,65,np.inf])

2.    ...: df.groupby(age_groups).mean()

运行结果如下：

按‘Age’分组范围和性别（sex）进行制作交叉表

1. In [27]: pd.crosstab(age_groups, df['Sex'])

运行结果如下：

参考文章：http://stackoverflow.com/documentation/pandas/1822/grouping-data#t=201705040520188108539